﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DbTaglio.SvcLayer.DbTaglioService;

namespace DbTaglio.SvcLayer
{
    public class MetGet : WcfBase
    {

        public MetGet(string pUserName, string pPwd, bool pImpersonate = true):
            base(pUserName ,pPwd ,pImpersonate)       
        {

        }

        public RetData<DBTWinLogin> GetDBTWinAndAppLogin(string pUserName)
        {
             return Execute2<Boolean,string,DBTWinLogin>(Proxy.GetDBTWinLogin, false,pUserName);
        }//fM

        public RetData<string> GetWinUserName()
        {
            return Execute<string>(Proxy.GetWindowsUserName);
        }//fM

        //TODO : GeDatiUtenteApplicazione() 
        public RetData<string> GeDatiUtenteApplicazione()
        {
            throw new NotImplementedException("Metodo non implementato");
        }//fM


        public RetData<Commessa[]> getCommesse(CommessaSearchModel pFilter,bool pIsCombo)
        {
            if(pIsCombo) 
                return  Execute<CommessaSearchModel,Commessa[] >(Proxy.GetCommesseCombo, pFilter);
            else
                return Execute<CommessaSearchModel, Commessa[]>(Proxy.GetCommesseCombo, pFilter);
        }//fM


        public RetData<Terzista[]> getTerzisti(Boolean pFilter)
        { 
            return Execute<bool?,Terzista[]>( Proxy.GetTerzistiCombo, pFilter);
        }//fM

        public RetData<Terzista> getTerzista(string CodiceTerzista)
        {
            return Execute<string, Terzista>(Proxy.GetTerzista, CodiceTerzista);
        }//fM



        public RetData<Stagione[]> getStagioni(bool pIsCombo)
        {
             return Execute<Stagione[]>(Proxy.GetAllStagioni); //TODO : combo               
        }//fM


        public RetData<MasterItem[]> getMasterItems(ItemSearchModel pFilter,  bool pIsCombo)
        {
             return Execute<ItemSearchModel,MasterItem[]> ( Proxy.GetMasterItemsCombo, pFilter);  
        }//fM


        public RetData<Taglia[]> getMasterItemTaglie(MasterItem pMasterItem)
        {
             return Execute<MasterItem, Taglia[]>( Proxy.GetMasterItemTaglie, pMasterItem);
        }//fM


        //
        public RetData<Conceria[]> getConcerie(ConceriaSearchModel pFilter)
        {
            return Execute<ConceriaSearchModel, Conceria[]>(Proxy.GetConcerieCombo, pFilter);
        }//fM


        // TODO : da fare getMateriali
        public RetData<MasterItem[]> getMateriali(MasterItem pMasterItem)
        {
            MasterItem[] result = null;

            try
            {
                //result = Proxy.getm(pMasterItem);
                return new RetData<MasterItem[]>(result);
            }
            catch (Exception ex)
            {
                return new RetData<MasterItem[]>(ex);
            }

        }//fM


        // Si intendono le operazioni ??
        public RetData<Fase[]> getFasi(FaseSearchModel pFilter)
        {
             return Execute<FaseSearchModel, Fase[]>(Proxy.GetFasi, pFilter);
        }//fM


        //COMPONENTI
        public RetData<Componente[]> getComponenti()
        {
            return Execute<Componente[]>(Proxy.GetAllComponentiCombo);
        }//fM

        //COLORI
        public RetData<Colore[]> getColoriComponente(string pCodiceMat)
        {
            return Execute<string, Colore[]>(Proxy.GetColoriComponente, pCodiceMat);
        }//fM


        //OPERATORI
        public RetData<Operatore[]> getOperatori(DBTGenFiter pFilter)
        {
            return Execute<DBTGenFiter, Operatore[]>(Proxy.GetOperatoriFornitore, pFilter);
        }//fM


        //MACCHINE
        public RetData<Macchina[]> getMacchine(DBTGenFiter pFilter)
        {
            return Execute<DBTGenFiter, Macchina[]>(Proxy.GetMacchineFornitoreCombo, pFilter);
        }//fM

        // getDichiarazioni
        public RetData<Dichiarazione[]> getDichiarazioni(DichiarazioneSearchModel pFilter)
        {          
            return Execute<DichiarazioneSearchModel, Dichiarazione[]>(Proxy.GetDichiarazioni, pFilter);
        }//fM


        // Causale
        public RetData<Causale[]> getCausali(string pCodCausale, int pIdCausale)
        {
            return Execute2<string,int, Causale[]>(Proxy.GetCausali, pCodCausale, pIdCausale);
        }//fM


        //
        public RetData<Operativita[]> getOperativita(string pCodiceOperativita, int pIdOperativita)
        {
            return Execute2<string, int, Operativita[]>(Proxy.GetOperativita, pCodiceOperativita, pIdOperativita);
        }//fM


    }
}
